{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Preprocess CNAs from Firehose\n",
    "In this notebook, I want to preprocess all the CNA data that Hotnet2 used for their identification of significant submodules. I already downloaded the the output from GISTIC2 from Firehose, using the firehose_get tool with:\n",
    "\n",
    "`./firehose_get -tasks gistic analysis latest`\n",
    "\n",
    "The notebook assumes that there is one folder, containing gzipped folders for each cancer type.\n",
    "The result are two matrices that are written to disk.\n",
    "\n",
    "* The first matrix has shape $\\big(genes \\times cancertypes\\big) \\in \\mathrm{R}$ and contains the mean number of samples for which the gene was affected.\n",
    "* The second matrix $\\big(genes \\times samples\\big) \\in \\{0, 1\\}$ contains a $1$ if the gene in the sample is affected by a CNA and $0$ otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import gzip\n",
    "import os, sys\n",
    "import tarfile\n",
    "import umap\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "%matplotlib inline\n",
    "\n",
    "# test\n",
    "import mygene"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Parameters for the Script\n",
    "The parameters have the following meaning:\n",
    "* `GISTIC_THRESHOLD`: GISTIC2 writes for each sample if a CNA is affecting the gene with a high probability (2) and medium probability (1) or not (0). Setting the threshold to 1 means that you also use CNAs with medium probability. Setting it to 2 means that you use only high confidence CNAs.\n",
    "* `REMOVE_INCONSISTENT_CNAS`: Don't consider CNAs that are not at least present in 75% of samples. This was done in the Hotnet2 preprocessing.\n",
    "* `ANALYSIS_DATE`: Firehose has multiple analyses done and they can be downloaded at different time points. Currently (April 2018), `latest` in the firehose_get command refers to 20160128.\n",
    "* `ROOT_DIR`: The directory in which the firehose data can be found.\n",
    "* `CANCER_TYPES`: The cancer types you are interested in as a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "GISTIC_THRESHOLD = 1\n",
    "REMOVE_INCONSISTENT_CNAS = False\n",
    "ANALYSIS_DATE = '20160128' # latest\n",
    "ROOT_DIR = '../../data/pancancer/firehose/analyses__2016_01_28/' # where the firehose download is located\n",
    "# CANCER_TYPES describes the cancer types, I am interested in\n",
    "CANCER_TYPES = ['BRCA', 'LUAD', 'UCEC', 'KIRC', 'HNSC', 'THCA', 'LUSC', 'PRAD', 'COAD', 'STAD', 'BLCA', 'LIHC', 'CESC', 'KIRP', 'ESCA', 'READ']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "def get_target_genes(fname):\n",
    "    \"\"\"Extract all genes per CNA from file\n",
    "    \n",
    "    This method extracts the target genes for all CNAs (either amps or dels) from GISTIC2 output files.\n",
    "    Parameters:\n",
    "    ---------\n",
    "    fname:            The file to read from\n",
    "    \n",
    "    Returns:\n",
    "    A dictionary with the descriptors of the CNAs as keys. The values are lists of target genes.\n",
    "    \"\"\"\n",
    "    cna_genes_df = pd.read_csv(fname, sep='\\t')\n",
    "    relevant_cols = cna_genes_df.iloc[3:, 1:].dropna(how='all', axis=1)\n",
    "    genes_per_cna = {}\n",
    "    for col in relevant_cols.columns:\n",
    "        genes_per_cna[col] = [i.split('|')[0].lstrip('[').rstrip(']') for i in relevant_cols[col].dropna().tolist()]\n",
    "    return genes_per_cna\n",
    "\n",
    "def get_genes_from_target_dict(genes_per_cna):\n",
    "    return list(set({x for v in genes_per_cna.values() for x in v}))\n",
    "\n",
    "def get_samples(lesions):\n",
    "    return lesions.iloc[:, 9:].dropna(how='all', axis=1).columns\n",
    "\n",
    "\n",
    "def get_target_genes_from_gistic(lesions, amps, dels):\n",
    "    # first, get the target genes for all CNAs\n",
    "    amp_targets = get_target_genes(amps)\n",
    "    del_targets = get_target_genes(dels)\n",
    "    all_targets = {**amp_targets, **del_targets} # no duplicate keys possible\n",
    "    list_of_targets = get_genes_from_target_dict(all_targets)\n",
    "    \n",
    "    # Next, get the sample IDs\n",
    "    all_lesions = pd.read_csv(lesions, sep='\\t')\n",
    "    if REMOVE_INCONSISTENT_CNAS:\n",
    "        mean_cnas = (all_lesions.iloc[:, 9:] >= GISTIC_THRESHOLD).mean(axis=1)\n",
    "        all_lesions = all_lesions[mean_cnas >= .75]\n",
    "    samples = get_samples(all_lesions)\n",
    "    \n",
    "    # construct target matrix (genes x samples; 1 indicates that sample has CNA affecting the gene)\n",
    "    target_gene_matrix = pd.DataFrame(0, index=list_of_targets, columns=samples)\n",
    "    all_lesions = all_lesions[~all_lesions['Unique Name'].str.contains(\"CN values\")]\n",
    "    for sample in samples:\n",
    "        cnas = all_lesions[all_lesions.loc[:, sample] >= GISTIC_THRESHOLD].Descriptor\n",
    "        genes_subset = dict((k, all_targets[k.strip()]) for k in cnas)\n",
    "        target_genes_for_sample = get_genes_from_target_dict(genes_subset)\n",
    "        target_gene_matrix.loc[target_gene_matrix.index.isin(target_genes_for_sample), sample] = 1\n",
    "    return target_gene_matrix\n",
    "    \n",
    "\n",
    "def get_target_genes_per_sample(root_dir, cancer_type, analysis_date):\n",
    "    analysis_dir = 'gdac.broadinstitute.org_{}-T{}.CopyNumber_Gistic2.Level_4.{}00.0.0.tar.gz'\n",
    "    p = os.path.join(root_dir, analysis_dir.format(cancer_type, 'B' if cancer_type is 'LAML' else 'P', analysis_date))\n",
    "    if os.path.isfile(p):\n",
    "        #print (\"Extracting target genes from {}\".format(p))\n",
    "        dir_prefix = analysis_dir.rstrip(\".tar.gz\").format(cancer_type,\n",
    "                                                           'B' if cancer_type is 'LAML' else 'P',\n",
    "                                                           analysis_date)\n",
    "        tar = tarfile.open(p, \"r:gz\")\n",
    "        lesions_tar = tar.extractfile(tar.getmember(os.path.join(dir_prefix, 'all_lesions.conf_99.txt')))\n",
    "        amp_tar = tar.extractfile(tar.getmember(os.path.join(dir_prefix, 'amp_genes.conf_99.txt')))\n",
    "        del_tar = tar.extractfile(tar.getmember(os.path.join(dir_prefix, 'del_genes.conf_99.txt')))\n",
    "        return get_target_genes_from_gistic(lesions_tar, amp_tar, del_tar)\n",
    "    else:\n",
    "        print (\"Error. Path {} does not exist\".format(p))\n",
    "\n",
    "def extract_targets_all_cancers(root_dir, analysis_date, cancer_types):\n",
    "    result_samples = None\n",
    "    result_cancertype = None\n",
    "    for cancer_type in cancer_types:\n",
    "        sample_matrix = get_target_genes_per_sample(os.path.join(root_dir, cancer_type, analysis_date),\n",
    "                                                    cancer_type, analysis_date)\n",
    "        mean_matrix = pd.DataFrame(sample_matrix.mean(axis=1), columns=[cancer_type])\n",
    "        print (\"For Cancer {}:\".format(cancer_type))\n",
    "        print (\"Found {} genes for {} samples with avg {} mutated genes\".format(sample_matrix.shape[0],\n",
    "                                                                                sample_matrix.shape[1],\n",
    "                                                                                sample_matrix.sum().sum() / sample_matrix.shape[1]))\n",
    "        print (\"{0:.2f}% mutations across all samples\".format((sample_matrix.sum().sum() / np.prod(sample_matrix.shape))*100))\n",
    "        print (\"-----------------------------------------\")\n",
    "        if result_samples is None:\n",
    "            result_samples = sample_matrix\n",
    "            result_cancertype = mean_matrix\n",
    "            \n",
    "        else:\n",
    "            result_samples = result_samples.append(sample_matrix)\n",
    "            result_cancertype = result_cancertype.append(mean_matrix)\n",
    "            \n",
    "    result_samples.fillna(0, inplace=True)\n",
    "    result_cancertype.fillna(0, inplace=True)\n",
    "    result_samples = result_samples.groupby(result_samples.index).sum()\n",
    "    result_cancertype = result_cancertype.groupby(result_cancertype.index).sum()\n",
    "    return result_samples, result_cancertype\n",
    "\n",
    "def extract_threshold_matrices(root_dir, analysis_date, cancer_types):\n",
    "    result_samples = None\n",
    "    result_cancertype = None\n",
    "    for cancer_type in cancer_types:\n",
    "        analysis_dir = 'gdac.broadinstitute.org_{}-T{}.CopyNumber_Gistic2.Level_4.{}00.0.0.tar.gz'\n",
    "        base_dir = os.path.join(root_dir, cancer_type, analysis_date)\n",
    "        p = os.path.join(base_dir, analysis_dir.format(cancer_type, 'B' if cancer_type is 'LAML' else 'P', analysis_date))\n",
    "        dir_prefix = analysis_dir.rstrip(\".tar.gz\").format(cancer_type,\n",
    "                                                           'B' if cancer_type is 'LAML' else 'P',\n",
    "                                                           analysis_date)\n",
    "        with tarfile.open(p, \"r:gz\") as tar:\n",
    "            sample_path = tar.extractfile(tar.getmember(os.path.join(dir_prefix, 'all_thresholded.by_genes.txt')))\n",
    "            sample_matrix = pd.read_csv(sample_path, sep='\\t')\n",
    "        sample_matrix.drop(['Locus ID', 'Cytoband'], axis=1, inplace=True)\n",
    "        sample_matrix.set_index('Gene Symbol', inplace=True)\n",
    "        if GISTIC_THRESHOLD == 2:\n",
    "            sample_matrix.replace(1, 0, inplace=True)\n",
    "            sample_matrix.replace(-1, 0, inplace=True)\n",
    "            sample_matrix.replace(2, 1, inplace=True)\n",
    "            sample_matrix.replace(-2, -1, inplace=True)\n",
    "        mean_matrix = pd.DataFrame(sample_matrix.mean(axis=1), columns=[cancer_type])\n",
    "        print (\"For Cancer {}:\".format(cancer_type))\n",
    "        print (\"Found {} genes for {} samples with avg {} mutated genes\".format(sample_matrix.shape[0],\n",
    "                                                                                sample_matrix.shape[1],\n",
    "                                                                                sample_matrix.sum().sum() / sample_matrix.shape[1]))\n",
    "        print (\"{0:.2f}% mutations across all samples\".format((sample_matrix.sum().sum() / np.prod(sample_matrix.shape))*100))\n",
    "        print (\"-----------------------------------------\")\n",
    "        if result_samples is None:\n",
    "            result_samples = sample_matrix\n",
    "            result_cancertype = mean_matrix\n",
    "            \n",
    "        else:\n",
    "            result_samples = result_samples.append(sample_matrix)\n",
    "            result_cancertype = result_cancertype.append(mean_matrix)\n",
    "            \n",
    "    result_samples.fillna(0, inplace=True)\n",
    "    result_cancertype.fillna(0, inplace=True)\n",
    "    result_samples = result_samples.groupby(result_samples.index).sum()\n",
    "    result_cancertype = result_cancertype.groupby(result_cancertype.index).sum()\n",
    "    return result_samples, result_cancertype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For Cancer BRCA:\n",
      "Found 2920 genes for 1080 samples with avg 51.06296296296296 mutated genes\n",
      "1.75% mutations across all samples\n",
      "-----------------------------------------\n",
      "For Cancer LUAD:\n",
      "Found 6125 genes for 516 samples with avg 54.88178294573643 mutated genes\n",
      "0.90% mutations across all samples\n",
      "-----------------------------------------\n",
      "For Cancer UCEC:\n",
      "Found 3414 genes for 539 samples with avg 66.36363636363636 mutated genes\n",
      "1.94% mutations across all samples\n",
      "-----------------------------------------\n",
      "For Cancer KIRC:\n",
      "Found 5524 genes for 528 samples with avg 38.32954545454545 mutated genes\n",
      "0.69% mutations across all samples\n",
      "-----------------------------------------\n",
      "For Cancer HNSC:\n",
      "Found 3566 genes for 522 samples with avg 24.93295019157088 mutated genes\n",
      "0.70% mutations across all samples\n",
      "-----------------------------------------\n",
      "For Cancer THCA:\n",
      "Found 8454 genes for 499 samples with avg 5.809619238476954 mutated genes\n",
      "0.07% mutations across all samples\n",
      "-----------------------------------------\n",
      "For Cancer LUSC:\n",
      "Found 4496 genes for 501 samples with avg 93.19760479041916 mutated genes\n",
      "2.07% mutations across all samples\n",
      "-----------------------------------------\n",
      "For Cancer PRAD:\n",
      "Found 4009 genes for 492 samples with avg 47.5650406504065 mutated genes\n",
      "1.19% mutations across all samples\n",
      "-----------------------------------------\n",
      "For Cancer COAD:\n",
      "Found 3155 genes for 451 samples with avg 38.674057649667404 mutated genes\n",
      "1.23% mutations across all samples\n",
      "-----------------------------------------\n",
      "For Cancer STAD:\n",
      "Found 3086 genes for 441 samples with avg 32.95238095238095 mutated genes\n",
      "1.07% mutations across all samples\n",
      "-----------------------------------------\n",
      "For Cancer BLCA:\n",
      "Found 3687 genes for 408 samples with avg 81.5 mutated genes\n",
      "2.21% mutations across all samples\n",
      "-----------------------------------------\n",
      "For Cancer LIHC:\n",
      "Found 4404 genes for 370 samples with avg 120.67297297297297 mutated genes\n",
      "2.74% mutations across all samples\n",
      "-----------------------------------------\n",
      "For Cancer CESC:\n",
      "Found 5295 genes for 295 samples with avg 79.37627118644068 mutated genes\n",
      "1.50% mutations across all samples\n",
      "-----------------------------------------\n",
      "For Cancer KIRP:\n",
      "Found 5995 genes for 288 samples with avg 55.46875 mutated genes\n",
      "0.93% mutations across all samples\n",
      "-----------------------------------------\n",
      "For Cancer ESCA:\n",
      "Found 4153 genes for 184 samples with avg 69.0054347826087 mutated genes\n",
      "1.66% mutations across all samples\n",
      "-----------------------------------------\n",
      "For Cancer READ:\n",
      "Found 7744 genes for 165 samples with avg 186.0909090909091 mutated genes\n",
      "2.40% mutations across all samples\n",
      "-----------------------------------------\n"
     ]
    }
   ],
   "source": [
    "cna_sample_matrix, cna_mean_matrix = extract_targets_all_cancers(ROOT_DIR, ANALYSIS_DATE, CANCER_TYPES)\n",
    "#cna_sample_matrix, cna_mean_matrix = extract_threshold_matrices(ROOT_DIR, ANALYSIS_DATE, CANCER_TYPES)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='ctype', ylabel='value'>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#ax = cna_mean_matrix.plot(kind='box', figsize=(16, 10), title='CNAs across different cancer types')\n",
    "#ax.set_ylabel('Frequency of genes affected by CNAs')\n",
    "fig = plt.figure(figsize=(20, 10))\n",
    "sns.boxplot(x='ctype', y='value', data=pd.melt(cna_mean_matrix, var_name='ctype'), showfliers=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "cna_mean_matrix.to_csv('../../data/pancancer/TCGA/mutation/firehose_cnas_meancancertypes_{}.tsv'.format(ANALYSIS_DATE), sep='\\t')\n",
    "cna_sample_matrix_int = cna_sample_matrix.astype(np.uint8) # saves space and time\n",
    "cna_sample_matrix_int.to_csv('../../data/pancancer/TCGA/mutation/firehose_cnas_sample_{}.tsv'.format(ANALYSIS_DATE))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot UMAP embedding of CNA information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7279, 2)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embedding = umap.UMAP(n_components=2).fit_transform(cna_sample_matrix.T)\n",
    "embedding.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>pc1</th>\n",
       "      <th>pc2</th>\n",
       "      <th>cancertype</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>TCGA-3C-AAAU</th>\n",
       "      <td>9.885818</td>\n",
       "      <td>-6.540962</td>\n",
       "      <td>BRCA</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>TCGA-3C-AALI</th>\n",
       "      <td>5.449465</td>\n",
       "      <td>-7.137625</td>\n",
       "      <td>BRCA</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>TCGA-3C-AALJ</th>\n",
       "      <td>5.200467</td>\n",
       "      <td>-6.920860</td>\n",
       "      <td>BRCA</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>TCGA-3C-AALK</th>\n",
       "      <td>5.423285</td>\n",
       "      <td>-7.095293</td>\n",
       "      <td>BRCA</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>TCGA-4H-AAAK</th>\n",
       "      <td>-3.154272</td>\n",
       "      <td>3.738188</td>\n",
       "      <td>BRCA</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   pc1       pc2 cancertype\n",
       "TCGA-3C-AAAU  9.885818 -6.540962       BRCA\n",
       "TCGA-3C-AALI  5.449465 -7.137625       BRCA\n",
       "TCGA-3C-AALJ  5.200467 -6.920860       BRCA\n",
       "TCGA-3C-AALK  5.423285 -7.095293       BRCA\n",
       "TCGA-4H-AAAK -3.154272  3.738188       BRCA"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "long = pd.DataFrame(embedding, columns=['pc1', 'pc2'], index=cna_sample_matrix.columns)\n",
    "submitter_project_mapping = pd.read_json('../../data/pancancer/TCGA/mutation/download_new/cases_all_cancers.2018-11-26.json')\n",
    "submitter_project_mapping.head()\n",
    "submitter_project_mapping['cancertype'] = [dict(i)['project_id'].split('-')[1] for i in submitter_project_mapping.project]\n",
    "submitter_project_mapping = submitter_project_mapping[['submitter_id', 'cancertype']].set_index('submitter_id')\n",
    "submitter_project_mapping.head()\n",
    "trim_to_submitter = lambda x: '-'.join(str(x).split('-')[:3]) # TCGA barcode until patient\n",
    "long.index = long.index.map(trim_to_submitter)\n",
    "long_with_ctypes = long.join(submitter_project_mapping)\n",
    "long_with_ctypes.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1224x864 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(17, 12))\n",
    "g = sns.scatterplot(x='pc1', y='pc2', data=long_with_ctypes, hue='cancertype', s=100, alpha=.9,\n",
    "                    palette=sns.color_palette(n_colors=long_with_ctypes.cancertype.nunique()))\n",
    "plt.xlabel('Component 1', fontsize=25)\n",
    "plt.ylabel('Component 2', fontsize=25)\n",
    "legend = plt.legend(bbox_to_anchor=(1.1, 1), loc=2, borderaxespad=0., prop={'size': 23.5}, handlelength=1,\n",
    "                    markerscale=2.5)\n",
    "plt.title('UMAP Embedding of CNAs for Samples', fontsize=30)\n",
    "fig.savefig('../../data/pancancer/TCGA/mutation/UMAP_CNAs_THR{}.png'.format(GISTIC_THRESHOLD, dpi=300))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_gene_symbols(list_of_ensembl_ids):\n",
    "    # get Ensembl IDs for gene names\n",
    "    mg = mygene.MyGeneInfo()\n",
    "    res = mg.querymany(list_of_ensembl_ids,\n",
    "                       scopes='ensembl.gene',\n",
    "                       fields='symbol',\n",
    "                       species='human', returnall=True\n",
    "                      )\n",
    "\n",
    "    def get_symbol_and_ensembl(d):\n",
    "        if 'symbol' in d:\n",
    "            return [d['query'], d['symbol']]\n",
    "        else:\n",
    "            return [d['query'], None]\n",
    "\n",
    "    node_names = [get_symbol_and_ensembl(d) for d in res['out']]\n",
    "    # now, retrieve the names and IDs from a dictionary and put in DF\n",
    "    node_names = pd.DataFrame(node_names, columns=['Ensembl_ID', 'Symbol']).set_index('Ensembl_ID')\n",
    "    node_names.dropna(axis=0, inplace=True)\n",
    "    return node_names\n",
    "\n",
    "def get_ensembl_ids(list_of_gene_symbols):\n",
    "    # get Ensembl IDs for gene names\n",
    "    mg = mygene.MyGeneInfo()\n",
    "    res = mg.querymany(list_of_gene_symbols,\n",
    "                       scopes='symbol, refseq, uniprot',\n",
    "                       fields='ensembl.gene',\n",
    "                       species='human', returnall=True\n",
    "                      )\n",
    "\n",
    "    # now, retrieve the names and IDs from a dictionary and put in DF\n",
    "    def get_name_and_id(x):\n",
    "        if 'ensembl' in x:\n",
    "            ens_id = x['ensembl'][0]['gene'] if type(x['ensembl']) is list else x['ensembl']['gene']\n",
    "            symbol = x['query']\n",
    "            return [symbol, ens_id]\n",
    "        else:\n",
    "            return [x['query'], None]\n",
    "\n",
    "    ens_ids = [get_name_and_id(x) for x in res['out']]\n",
    "    \n",
    "    node_names = pd.DataFrame(ens_ids, columns=['Symbol', 'Ensembl_ID']).set_index('Ensembl_ID')\n",
    "    node_names.dropna(axis=0, inplace=True)\n",
    "    node_names.drop_duplicates(inplace=True)\n",
    "    return node_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>68cef882-5ac4-4c7b-9d99-3bc3bc15d0fe</th>\n",
       "      <th>d59d48ca-16e5-46c0-80e8-6d1214acd156</th>\n",
       "      <th>5c618903-3b51-475b-837e-a56680a7cf80</th>\n",
       "      <th>1d160de2-9c94-4172-9934-aad4322a5141</th>\n",
       "      <th>00e2a4bb-6ef0-4e36-88ba-d0cb858b55e6</th>\n",
       "      <th>75f64631-fcf0-4dad-9d25-c400126bcecb</th>\n",
       "      <th>321f7819-40df-4d1a-a2dd-739bedaf21e0</th>\n",
       "      <th>98bf8cd9-4d14-46d2-b20a-d2c7533e4391</th>\n",
       "      <th>6588b3af-1812-4203-aa6d-55c73d05b9ee</th>\n",
       "      <th>02d3b1e9-adaa-4722-8579-b69999e7ff37</th>\n",
       "      <th>...</th>\n",
       "      <th>2deb5157-dba6-43e3-b231-c13af5a1988c</th>\n",
       "      <th>a51cc246-1b2e-4639-8966-de050a21fdd8</th>\n",
       "      <th>12cc440c-3723-4c92-b989-7c35cd03cbe4</th>\n",
       "      <th>57f8cf7e-216b-470a-9b60-9c505a262a3d</th>\n",
       "      <th>f7edcec3-b0fa-4eec-9b20-4c549b4075c1</th>\n",
       "      <th>cd1e5b56-4216-44d6-9f67-805ff88c2155</th>\n",
       "      <th>074c98bd-ae0c-4f93-a18a-024faecfe555</th>\n",
       "      <th>6ff53711-efbf-4db9-95f1-71f343af0aae</th>\n",
       "      <th>6069177a-b833-4121-9622-6435164b1413</th>\n",
       "      <th>ead101ca-8ffc-46b1-93db-0022fb0d88a7</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Gene Symbol</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>ENSG00000008128.21</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ENSG00000008130.14</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ENSG00000067606.14</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ENSG00000078369.16</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ENSG00000078808.15</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 415 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                    68cef882-5ac4-4c7b-9d99-3bc3bc15d0fe  \\\n",
       "Gene Symbol                                                \n",
       "ENSG00000008128.21                                     0   \n",
       "ENSG00000008130.14                                     0   \n",
       "ENSG00000067606.14                                     0   \n",
       "ENSG00000078369.16                                     0   \n",
       "ENSG00000078808.15                                     0   \n",
       "\n",
       "                    d59d48ca-16e5-46c0-80e8-6d1214acd156  \\\n",
       "Gene Symbol                                                \n",
       "ENSG00000008128.21                                     0   \n",
       "ENSG00000008130.14                                     0   \n",
       "ENSG00000067606.14                                     0   \n",
       "ENSG00000078369.16                                     0   \n",
       "ENSG00000078808.15                                     0   \n",
       "\n",
       "                    5c618903-3b51-475b-837e-a56680a7cf80  \\\n",
       "Gene Symbol                                                \n",
       "ENSG00000008128.21                                     0   \n",
       "ENSG00000008130.14                                     0   \n",
       "ENSG00000067606.14                                     0   \n",
       "ENSG00000078369.16                                     0   \n",
       "ENSG00000078808.15                                     0   \n",
       "\n",
       "                    1d160de2-9c94-4172-9934-aad4322a5141  \\\n",
       "Gene Symbol                                                \n",
       "ENSG00000008128.21                                     0   \n",
       "ENSG00000008130.14                                     0   \n",
       "ENSG00000067606.14                                     0   \n",
       "ENSG00000078369.16                                     0   \n",
       "ENSG00000078808.15                                     0   \n",
       "\n",
       "                    00e2a4bb-6ef0-4e36-88ba-d0cb858b55e6  \\\n",
       "Gene Symbol                                                \n",
       "ENSG00000008128.21                                     0   \n",
       "ENSG00000008130.14                                     0   \n",
       "ENSG00000067606.14                                     0   \n",
       "ENSG00000078369.16                                     0   \n",
       "ENSG00000078808.15                                     0   \n",
       "\n",
       "                    75f64631-fcf0-4dad-9d25-c400126bcecb  \\\n",
       "Gene Symbol                                                \n",
       "ENSG00000008128.21                                     0   \n",
       "ENSG00000008130.14                                     0   \n",
       "ENSG00000067606.14                                     0   \n",
       "ENSG00000078369.16                                     0   \n",
       "ENSG00000078808.15                                     0   \n",
       "\n",
       "                    321f7819-40df-4d1a-a2dd-739bedaf21e0  \\\n",
       "Gene Symbol                                                \n",
       "ENSG00000008128.21                                     0   \n",
       "ENSG00000008130.14                                     0   \n",
       "ENSG00000067606.14                                     0   \n",
       "ENSG00000078369.16                                     0   \n",
       "ENSG00000078808.15                                     0   \n",
       "\n",
       "                    98bf8cd9-4d14-46d2-b20a-d2c7533e4391  \\\n",
       "Gene Symbol                                                \n",
       "ENSG00000008128.21                                     0   \n",
       "ENSG00000008130.14                                     0   \n",
       "ENSG00000067606.14                                     0   \n",
       "ENSG00000078369.16                                     0   \n",
       "ENSG00000078808.15                                     0   \n",
       "\n",
       "                    6588b3af-1812-4203-aa6d-55c73d05b9ee  \\\n",
       "Gene Symbol                                                \n",
       "ENSG00000008128.21                                    -1   \n",
       "ENSG00000008130.14                                    -1   \n",
       "ENSG00000067606.14                                    -1   \n",
       "ENSG00000078369.16                                    -1   \n",
       "ENSG00000078808.15                                    -1   \n",
       "\n",
       "                    02d3b1e9-adaa-4722-8579-b69999e7ff37  \\\n",
       "Gene Symbol                                                \n",
       "ENSG00000008128.21                                     0   \n",
       "ENSG00000008130.14                                     0   \n",
       "ENSG00000067606.14                                     0   \n",
       "ENSG00000078369.16                                     0   \n",
       "ENSG00000078808.15                                     0   \n",
       "\n",
       "                                    ...                   \\\n",
       "Gene Symbol                         ...                    \n",
       "ENSG00000008128.21                  ...                    \n",
       "ENSG00000008130.14                  ...                    \n",
       "ENSG00000067606.14                  ...                    \n",
       "ENSG00000078369.16                  ...                    \n",
       "ENSG00000078808.15                  ...                    \n",
       "\n",
       "                    2deb5157-dba6-43e3-b231-c13af5a1988c  \\\n",
       "Gene Symbol                                                \n",
       "ENSG00000008128.21                                     0   \n",
       "ENSG00000008130.14                                     0   \n",
       "ENSG00000067606.14                                     0   \n",
       "ENSG00000078369.16                                     0   \n",
       "ENSG00000078808.15                                     0   \n",
       "\n",
       "                    a51cc246-1b2e-4639-8966-de050a21fdd8  \\\n",
       "Gene Symbol                                                \n",
       "ENSG00000008128.21                                     0   \n",
       "ENSG00000008130.14                                     0   \n",
       "ENSG00000067606.14                                     0   \n",
       "ENSG00000078369.16                                     0   \n",
       "ENSG00000078808.15                                     0   \n",
       "\n",
       "                    12cc440c-3723-4c92-b989-7c35cd03cbe4  \\\n",
       "Gene Symbol                                                \n",
       "ENSG00000008128.21                                     0   \n",
       "ENSG00000008130.14                                     0   \n",
       "ENSG00000067606.14                                     0   \n",
       "ENSG00000078369.16                                     0   \n",
       "ENSG00000078808.15                                     0   \n",
       "\n",
       "                    57f8cf7e-216b-470a-9b60-9c505a262a3d  \\\n",
       "Gene Symbol                                                \n",
       "ENSG00000008128.21                                    -1   \n",
       "ENSG00000008130.14                                    -1   \n",
       "ENSG00000067606.14                                    -1   \n",
       "ENSG00000078369.16                                    -1   \n",
       "ENSG00000078808.15                                    -1   \n",
       "\n",
       "                    f7edcec3-b0fa-4eec-9b20-4c549b4075c1  \\\n",
       "Gene Symbol                                                \n",
       "ENSG00000008128.21                                     0   \n",
       "ENSG00000008130.14                                     0   \n",
       "ENSG00000067606.14                                     0   \n",
       "ENSG00000078369.16                                     0   \n",
       "ENSG00000078808.15                                     0   \n",
       "\n",
       "                    cd1e5b56-4216-44d6-9f67-805ff88c2155  \\\n",
       "Gene Symbol                                                \n",
       "ENSG00000008128.21                                     0   \n",
       "ENSG00000008130.14                                     0   \n",
       "ENSG00000067606.14                                     0   \n",
       "ENSG00000078369.16                                     0   \n",
       "ENSG00000078808.15                                     0   \n",
       "\n",
       "                    074c98bd-ae0c-4f93-a18a-024faecfe555  \\\n",
       "Gene Symbol                                                \n",
       "ENSG00000008128.21                                     1   \n",
       "ENSG00000008130.14                                     1   \n",
       "ENSG00000067606.14                                     1   \n",
       "ENSG00000078369.16                                     1   \n",
       "ENSG00000078808.15                                     1   \n",
       "\n",
       "                    6ff53711-efbf-4db9-95f1-71f343af0aae  \\\n",
       "Gene Symbol                                                \n",
       "ENSG00000008128.21                                     0   \n",
       "ENSG00000008130.14                                     0   \n",
       "ENSG00000067606.14                                     0   \n",
       "ENSG00000078369.16                                     0   \n",
       "ENSG00000078808.15                                     0   \n",
       "\n",
       "                    6069177a-b833-4121-9622-6435164b1413  \\\n",
       "Gene Symbol                                                \n",
       "ENSG00000008128.21                                     0   \n",
       "ENSG00000008130.14                                     0   \n",
       "ENSG00000067606.14                                     0   \n",
       "ENSG00000078369.16                                     0   \n",
       "ENSG00000078808.15                                     0   \n",
       "\n",
       "                    ead101ca-8ffc-46b1-93db-0022fb0d88a7  \n",
       "Gene Symbol                                               \n",
       "ENSG00000008128.21                                     0  \n",
       "ENSG00000008130.14                                     0  \n",
       "ENSG00000067606.14                                     0  \n",
       "ENSG00000078369.16                                     0  \n",
       "ENSG00000078808.15                                     0  \n",
       "\n",
       "[5 rows x 415 columns]"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test = pd.read_csv('../../data/pancancer/TCGA/mutation/CNA/BLCA.focal_score_by_genes.txt', sep='\\t')\n",
    "test.drop(['Gene ID', 'Cytoband'], axis=1, inplace=True)\n",
    "test.set_index('Gene Symbol', inplace=True)\n",
    "new_idx = [i[0] for i in test.index.str.split('.')]\n",
    "test['ID'] = new_idx\n",
    "test.set_index('ID', inplace=True)\n",
    "symbols = get_gene_symbols(test.index)\n",
    "test_names = test.join(symbols).set_index('Symbol')\n",
    "test_names = test_names.loc[~test_names.index.duplicated(keep='first')]\n",
    "test.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [],
   "source": [
    "cna_blca_matrix = cna_sample_matrix.loc[:, cna_sample_matrix.columns.isin(blca_df_reindexed.columns)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gdac.broadinstitute.org_BLCA-TP.CopyNumber_Gistic2.Level_4.2016012800.0.0/all_thresholded.by_genes.txt\n"
     ]
    }
   ],
   "source": [
    "p = '../../data/pancancer/firehose/analyses__2016_01_28/BLCA/20160128/gdac.broadinstitute.org_BLCA-TP.CopyNumber_Gistic2.Level_4.2016012800.0.0.tar.gz'\n",
    "prefix = 'gdac.broadinstitute.org_BLCA-TP.CopyNumber_Gistic2.Level_4.{}00.0.0'.format(ANALYSIS_DATE)\n",
    "print (os.path.join(prefix, 'all_thresholded.by_genes.txt'))\n",
    "tar = tarfile.open(p, \"r:gz\")\n",
    "blca_matrix = tar.extractfile(tar.getmember(os.path.join(prefix, 'all_thresholded.by_genes.txt')))\n",
    "tar.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>TCGA-2F-A9KO-01A-11D-A38F-01</th>\n",
       "      <th>TCGA-2F-A9KP-01A-11D-A38F-01</th>\n",
       "      <th>TCGA-2F-A9KQ-01A-11D-A38F-01</th>\n",
       "      <th>TCGA-2F-A9KR-01A-11D-A38F-01</th>\n",
       "      <th>TCGA-2F-A9KT-01A-11D-A38F-01</th>\n",
       "      <th>TCGA-2F-A9KW-01A-11D-A38F-01</th>\n",
       "      <th>TCGA-4Z-AA7M-01A-11D-A390-01</th>\n",
       "      <th>TCGA-4Z-AA7N-01A-11D-A390-01</th>\n",
       "      <th>TCGA-4Z-AA7O-01A-31D-A390-01</th>\n",
       "      <th>TCGA-4Z-AA7Q-01A-11D-A390-01</th>\n",
       "      <th>...</th>\n",
       "      <th>TCGA-ZF-AA4X-01A-11D-A38F-01</th>\n",
       "      <th>TCGA-ZF-AA51-01A-21D-A390-01</th>\n",
       "      <th>TCGA-ZF-AA52-01A-12D-A390-01</th>\n",
       "      <th>TCGA-ZF-AA53-01A-11D-A390-01</th>\n",
       "      <th>TCGA-ZF-AA54-01A-11D-A390-01</th>\n",
       "      <th>TCGA-ZF-AA56-01A-31D-A390-01</th>\n",
       "      <th>TCGA-ZF-AA58-01A-12D-A42D-01</th>\n",
       "      <th>TCGA-ZF-AA5H-01A-11D-A390-01</th>\n",
       "      <th>TCGA-ZF-AA5N-01A-11D-A42D-01</th>\n",
       "      <th>TCGA-ZF-AA5P-01A-11D-A390-01</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Gene Symbol</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>ACAP3</th>\n",
       "      <td>-1</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>-1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>-1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ACTRT2</th>\n",
       "      <td>-1</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>-1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>-1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AGRN</th>\n",
       "      <td>-1</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>-1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>-1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ANKRD65</th>\n",
       "      <td>-1</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>-1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>-1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ATAD3A</th>\n",
       "      <td>-1</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>-1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>-1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 408 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "             TCGA-2F-A9KO-01A-11D-A38F-01  TCGA-2F-A9KP-01A-11D-A38F-01  \\\n",
       "Gene Symbol                                                               \n",
       "ACAP3                                  -1                             2   \n",
       "ACTRT2                                 -1                             2   \n",
       "AGRN                                   -1                             2   \n",
       "ANKRD65                                -1                             2   \n",
       "ATAD3A                                 -1                             2   \n",
       "\n",
       "             TCGA-2F-A9KQ-01A-11D-A38F-01  TCGA-2F-A9KR-01A-11D-A38F-01  \\\n",
       "Gene Symbol                                                               \n",
       "ACAP3                                   0                             0   \n",
       "ACTRT2                                  0                             0   \n",
       "AGRN                                    0                             0   \n",
       "ANKRD65                                 0                             0   \n",
       "ATAD3A                                  0                             0   \n",
       "\n",
       "             TCGA-2F-A9KT-01A-11D-A38F-01  TCGA-2F-A9KW-01A-11D-A38F-01  \\\n",
       "Gene Symbol                                                               \n",
       "ACAP3                                   0                            -2   \n",
       "ACTRT2                                  0                            -2   \n",
       "AGRN                                    0                            -2   \n",
       "ANKRD65                                 0                            -2   \n",
       "ATAD3A                                  0                            -2   \n",
       "\n",
       "             TCGA-4Z-AA7M-01A-11D-A390-01  TCGA-4Z-AA7N-01A-11D-A390-01  \\\n",
       "Gene Symbol                                                               \n",
       "ACAP3                                   0                             0   \n",
       "ACTRT2                                  0                             0   \n",
       "AGRN                                    0                             0   \n",
       "ANKRD65                                 0                             0   \n",
       "ATAD3A                                  0                             0   \n",
       "\n",
       "             TCGA-4Z-AA7O-01A-31D-A390-01  TCGA-4Z-AA7Q-01A-11D-A390-01  \\\n",
       "Gene Symbol                                                               \n",
       "ACAP3                                   0                             0   \n",
       "ACTRT2                                  0                             0   \n",
       "AGRN                                    0                             0   \n",
       "ANKRD65                                 0                             0   \n",
       "ATAD3A                                  0                             0   \n",
       "\n",
       "                         ...               TCGA-ZF-AA4X-01A-11D-A38F-01  \\\n",
       "Gene Symbol              ...                                              \n",
       "ACAP3                    ...                                         -1   \n",
       "ACTRT2                   ...                                         -1   \n",
       "AGRN                     ...                                         -1   \n",
       "ANKRD65                  ...                                         -1   \n",
       "ATAD3A                   ...                                         -1   \n",
       "\n",
       "             TCGA-ZF-AA51-01A-21D-A390-01  TCGA-ZF-AA52-01A-12D-A390-01  \\\n",
       "Gene Symbol                                                               \n",
       "ACAP3                                   1                             1   \n",
       "ACTRT2                                  1                             1   \n",
       "AGRN                                    1                             1   \n",
       "ANKRD65                                 1                             1   \n",
       "ATAD3A                                  1                             1   \n",
       "\n",
       "             TCGA-ZF-AA53-01A-11D-A390-01  TCGA-ZF-AA54-01A-11D-A390-01  \\\n",
       "Gene Symbol                                                               \n",
       "ACAP3                                   1                            -1   \n",
       "ACTRT2                                  1                            -1   \n",
       "AGRN                                    1                            -1   \n",
       "ANKRD65                                 1                            -1   \n",
       "ATAD3A                                  1                            -1   \n",
       "\n",
       "             TCGA-ZF-AA56-01A-31D-A390-01  TCGA-ZF-AA58-01A-12D-A42D-01  \\\n",
       "Gene Symbol                                                               \n",
       "ACAP3                                   0                             0   \n",
       "ACTRT2                                  0                             0   \n",
       "AGRN                                    0                             0   \n",
       "ANKRD65                                 0                             0   \n",
       "ATAD3A                                  0                             0   \n",
       "\n",
       "             TCGA-ZF-AA5H-01A-11D-A390-01  TCGA-ZF-AA5N-01A-11D-A42D-01  \\\n",
       "Gene Symbol                                                               \n",
       "ACAP3                                   1                             0   \n",
       "ACTRT2                                  1                             0   \n",
       "AGRN                                    1                             0   \n",
       "ANKRD65                                 1                             0   \n",
       "ATAD3A                                  1                             0   \n",
       "\n",
       "             TCGA-ZF-AA5P-01A-11D-A390-01  \n",
       "Gene Symbol                                \n",
       "ACAP3                                   0  \n",
       "ACTRT2                                  0  \n",
       "AGRN                                    0  \n",
       "ANKRD65                                 0  \n",
       "ATAD3A                                  0  \n",
       "\n",
       "[5 rows x 408 columns]"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "blca_df = pd.read_csv(blca_matrix, sep='\\t')\n",
    "blca_df.drop(['Locus ID', 'Cytoband'], axis=1, inplace=True)\n",
    "blca_df.set_index('Gene Symbol', inplace=True)\n",
    "blca_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {},
   "outputs": [],
   "source": [
    "blca_df_reindexed = blca_df.reindex(cna_blca_matrix.index).dropna(axis=0)\n",
    "blca_df_reindexed = blca_df_reindexed.loc[~blca_df_reindexed.index.duplicated(keep='first')]\n",
    "cna_blca_matrix_reindexed = cna_blca_matrix.reindex(blca_df_reindexed.index)\n",
    "cna_blca_matrix_reindexed = cna_blca_matrix_reindexed.loc[~cna_blca_matrix_reindexed.index.duplicated(keep='first')]\n",
    "#test_reindexed = test_names.reindex(blca_df_reindexed.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(598.7230392155773, 801612)"
      ]
     },
     "execution_count": 241,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(blca_df_reindexed < -1).mean(axis=1).sum() + (blca_df > 1).mean(axis=1).sum(), (test < 0).sum(axis=1).sum() + (test > 0).sum(axis=1).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "224629"
      ]
     },
     "execution_count": 242,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(blca_df_reindexed > 1).sum(axis=1).sum() + (blca_df_reindexed < -1).sum(axis=1).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1742.7036144578294"
      ]
     },
     "execution_count": 243,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(test_reindexed > 0).mean(axis=1).sum() + (test_reindexed < 0).mean(axis=1).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((21789, 408), 32338.0)"
      ]
     },
     "execution_count": 254,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "blca_df_reindexed.shape, cna_blca_matrix_reindexed.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TCGA-2F-A9KO-01A-11D-A38F-01\n",
      "0.0 0.0\n",
      "(0,)\n",
      "AASDHPPT    0.0\n",
      "Name: TCGA-2F-A9KO-01A-11D-A38F-01, dtype: float64\n",
      "AASDHPPT    0.0\n",
      "Name: TCGA-2F-A9KO-01A-11D-A38F-01, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "for col in blca_df_reindexed.columns[:1]:\n",
    "    print (col)\n",
    "    level4_values = blca_df_reindexed.loc[:, col]\n",
    "    level4_values.replace(1, 0, inplace=True)\n",
    "    level4_values.replace(-1, 0, inplace=True)\n",
    "    level4_values.replace(2, 1, inplace=True)\n",
    "    level4_values.replace(-2, -1, inplace=True)\n",
    "    our_values = cna_blca_matrix_reindexed.loc[:, col]\n",
    "    print (our_values.min(), level4_values.min())\n",
    "    print (our_values[np.logical_xor((level4_values != 0), (our_values != 0))].shape)\n",
    "    print (level4_values[level4_values.index == 'AASDHPPT'])\n",
    "    print (our_values[our_values.index == 'AASDHPPT'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0, 0.0)"
      ]
     },
     "execution_count": 255,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "blca_df_reindexed.loc[:, 'TCGA-2F-A9KO-01A-11D-A38F-01'].sum(), cna_blca_matrix_reindexed.loc[:, 'TCGA-2F-A9KO-01A-11D-A38F-01'].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(146, 0)"
      ]
     },
     "execution_count": 261,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(np.abs(blca_df_reindexed.loc[:, 'TCGA-2F-A9KO-01A-11D-A38F-01']) == 2).sum(), (cna_blca_matrix_reindexed.loc[:, 'TCGA-2F-A9KO-01A-11D-A38F-01'] == 1).sum()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
